﻿#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map> // map的储存是有序的，因此才能使用sort进行排序
#include<unordered_map>  // unordered_map储存是无序的，不能使用sort等进行排序
#include<tuple>
#include<unordered_set>
#include<deque> // 双头队列，支持头和尾插入和删除

using namespace std;

void topic1() {
	int n, m;
	cin >> n >> m;
	vector<int>vec(n);
	for (int i = 0; i < n; i++)cin >> vec[i];

	// key为数据块， value为<下标，计数>
	map<vector<int>, pair<int, int>>umap;
	for (int i = 0; i <n; i+= m) { // 每次增加数据块长度m
		vector<int>cur_blk(vec.begin() + i, vec.begin() + min(i + m, n)); // 数据块长度
		if (umap.find(cur_blk) == umap.end()) { // 如果数据块不存在
			umap[cur_blk] = {i,1}; // 下标为i,只做位置标记
		}
		else {
			umap[cur_blk].second++;
		}
	}
	// 使用vector容器进行排序 
	vector<pair<vector<int>, pair<int, int>>>sorted_res(umap.begin(), umap.end());
	// 对下标进行排序
	sort(sorted_res.begin(), sorted_res.end(), [](const auto& a, const auto& b) {
		return a.second.first < b.second.first;
	});
	
	// 	先把数组整理一下
	vector<int>ans;
	for (const auto& kv : sorted_res) {
		// 数组插入，从尾部进行插入，元素为sorted_res第一个元素vector的从头到尾
		ans.insert(ans.end(), kv.first.begin(), kv.first.end());
		// 再插入计数
		ans.push_back(kv.second.second);
	}
	for (int i = 0; i < ans.size()-1; i++) {
		cout << ans[i] << " ";
	}
	cout << ans[ans.size() - 1];
}

int solve(deque<int>& machines, vector<int>& tasks) {
	for (int task : tasks) {
		int cnt = 0;  // 再每次拿出一个新任务时，都重新计数了

		// 循环进行替换
		// 如果一直匹配成功，cnt一直都是0，如果匹配失败，cnt失败才会++
		while(cnt<machines.size() && task != machines.front()){
			machines.push_back(machines.front());
			machines.pop_front();
			cnt++;
		}

		// 所以只要这轮没超就行
		if (cnt >= machines.size()) break;

		// 匹配成功
		if (task == machines.front()) machines.pop_front();
	}
	return machines.size();
}

// 任务调度
void topic2() {
	int n;
	cin >> n;
	vector<int>tasks(n);
	vector<int>machines(n);

	for (int i = 0; i < n; i++) {
		cin >> tasks[i];
	}
	for (int i = 0; i < n; i++){
		cin >> machines[i];
	}
	// machines中含有通用性执行机2，可以对2进行转换，要么全部转换成0要么全部转化成1
	
	// 所以分两种类别进行考虑,并且转成队列
	deque<int>mac0(machines.begin(), machines.end());
	deque<int>mac1(machines.begin(), machines.end());

	for (int& m : mac0) {
		if (m == 2) m = 0;
	}
	for (int& m : mac1) {
		if (m == 2) m = 1;
	}

	// 计算剩余的最小空置执行机数量
	cout << min(solve(mac0, tasks), solve(mac1, tasks)) << endl;
}

// 建立一个排斥关系，使用set来保证不重复
unordered_map<int, unordered_set<int>>umap;
int cost = 0;
int length = 1;  // 长度
int cur_length = 0;
int cur_cost = 0;

bool check(int cur, unordered_set<int>& used) {
	for (int u : used) {
		if (umap[u].count(cur) || umap[cur].count(u)) return false;
	}
	return true;
}

void dfs(vector<int>&times, unordered_set<int>& used, int start, int time) {
    // 终止条件：开始的下标超过数组,说明遍历到头了
	if (start > times.size() - 1) {
		// 比较长度，如果长度相等，则比较cost
		if(ans)
	}
	
	// 遍历所有元素
	for (int i = start; i <= times.size() - 1; i++) {
		// 验证当前元素与队列中的元素是否冲突
		if (check(i, used)) { 

		}
	}
}

void topic3() {
	int n;
	cin >> n;
	// 存放任务执行时间，保证下标对齐
	vector<int>times(n + 1);
	for (int i = 1; i <= n; i++) cin >> times[i];

	int muteNum;
	cin >> muteNum;
	for (int i = 0; i < muteNum; i++) {
		int a, b;
		cin >> a >> b;
		umap[a].insert(b);
		umap[b].insert(a);
	}

	unordered_set<int>usd;
	dfs(1,usd,0);

	cout << cost << endl;
}


int main() {
	//topic1();
	topic2();
	return 0;
}